// Generated from code/ch18/Cymbol.g by ANTLR 4.9.0-SNAPSHOT


import { ATN } from "antlr4ts/atn/ATN";
import { ATNDeserializer } from "antlr4ts/atn/ATNDeserializer";
import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
import { NotNull } from "antlr4ts/Decorators";
import { NoViableAltException } from "antlr4ts/NoViableAltException";
import { Override } from "antlr4ts/Decorators";
import { Parser } from "antlr4ts/Parser";
import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
import { ParserATNSimulator } from "antlr4ts/atn/ParserATNSimulator";
import { ParseTreeListener } from "antlr4ts/tree/ParseTreeListener";
import { ParseTreeVisitor } from "antlr4ts/tree/ParseTreeVisitor";
import { RecognitionException } from "antlr4ts/RecognitionException";
import { RuleContext } from "antlr4ts/RuleContext";
//import { RuleVersion } from "antlr4ts/RuleVersion";
import { TerminalNode } from "antlr4ts/tree/TerminalNode";
import { Token } from "antlr4ts/Token";
import { TokenStream } from "antlr4ts/TokenStream";
import { Vocabulary } from "antlr4ts/Vocabulary";
import { VocabularyImpl } from "antlr4ts/VocabularyImpl";

import * as Utils from "antlr4ts/misc/Utils";

import { CymbolListener } from "./CymbolListener";
import { CymbolVisitor } from "./CymbolVisitor";


export class CymbolParser extends Parser {
	public static readonly T__0 = 1;
	public static readonly T__1 = 2;
	public static readonly T__2 = 3;
	public static readonly T__3 = 4;
	public static readonly T__4 = 5;
	public static readonly T__5 = 6;
	public static readonly T__6 = 7;
	public static readonly T__7 = 8;
	public static readonly T__8 = 9;
	public static readonly T__9 = 10;
	public static readonly T__10 = 11;
	public static readonly T__11 = 12;
	public static readonly T__12 = 13;
	public static readonly T__13 = 14;
	public static readonly ID = 15;
	public static readonly INT = 16;
	public static readonly WS = 17;
	public static readonly SL_COMMENT = 18;
	public static readonly RULE_compilationUnit = 0;
	public static readonly RULE_varDeclaration = 1;
	public static readonly RULE_methodDeclaration = 2;
	public static readonly RULE_formalParmeters = 3;
	public static readonly RULE_block = 4;
	public static readonly RULE_structDeclaration = 5;
	public static readonly RULE_structMember = 6;
	public static readonly RULE_statement = 7;
	public static readonly RULE_expressionList = 8;
	public static readonly RULE_expression = 9;
	public static readonly RULE_addExpression = 10;
	public static readonly RULE_postfixEpression = 11;
	public static readonly RULE_primary = 12;
	public static readonly RULE_type = 13;
	// tslint:disable:no-trailing-whitespace
	public static readonly ruleNames: string[] = [
		"compilationUnit", "varDeclaration", "methodDeclaration", "formalParmeters", 
		"block", "structDeclaration", "structMember", "statement", "expressionList", 
		"expression", "addExpression", "postfixEpression", "primary", "type",
	];

	private static readonly _LITERAL_NAMES: Array<string | undefined> = [
		undefined, "'='", "';'", "'('", "')'", "','", "'{'", "'}'", "'struct'", 
		"'return'", "'+'", "'.'", "'float'", "'int'", "'void'",
	];
	private static readonly _SYMBOLIC_NAMES: Array<string | undefined> = [
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, undefined, undefined, undefined, undefined, undefined, undefined, 
		undefined, "ID", "INT", "WS", "SL_COMMENT",
	];
	public static readonly VOCABULARY: Vocabulary = new VocabularyImpl(CymbolParser._LITERAL_NAMES, CymbolParser._SYMBOLIC_NAMES, []);

	// @Override
	// @NotNull
	public get vocabulary(): Vocabulary {
		return CymbolParser.VOCABULARY;
	}
	// tslint:enable:no-trailing-whitespace

	// @Override
	public get grammarFileName(): string { return "Cymbol.g"; }

	// @Override
	public get ruleNames(): string[] { return CymbolParser.ruleNames; }

	// @Override
	public get serializedATN(): string { return CymbolParser._serializedATN; }

	protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException {
		return new FailedPredicateException(this, predicate, message);
	}

	constructor(input: TokenStream) {
		super(input);
		this._interp = new ParserATNSimulator(CymbolParser._ATN, this);
	}
	// @RuleVersion(0)
	public compilationUnit(): CompilationUnitContext {
		let _localctx: CompilationUnitContext = new CompilationUnitContext(this._ctx, this.state);
		this.enterRule(_localctx, 0, CymbolParser.RULE_compilationUnit);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 33;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << CymbolParser.T__7) | (1 << CymbolParser.T__11) | (1 << CymbolParser.T__12) | (1 << CymbolParser.T__13) | (1 << CymbolParser.ID))) !== 0)) {
				{
				this.state = 31;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 0, this._ctx) ) {
				case 1:
					{
					this.state = 28;
					this.varDeclaration();
					}
					break;

				case 2:
					{
					this.state = 29;
					this.methodDeclaration();
					}
					break;

				case 3:
					{
					this.state = 30;
					this.structDeclaration();
					}
					break;
				}
				}
				this.state = 35;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public varDeclaration(): VarDeclarationContext {
		let _localctx: VarDeclarationContext = new VarDeclarationContext(this._ctx, this.state);
		this.enterRule(_localctx, 2, CymbolParser.RULE_varDeclaration);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 36;
			this.type();
			this.state = 37;
			this.match(CymbolParser.ID);
			this.state = 40;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === CymbolParser.T__0) {
				{
				this.state = 38;
				this.match(CymbolParser.T__0);
				this.state = 39;
				this.expression();
				}
			}

			this.state = 42;
			this.match(CymbolParser.T__1);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public methodDeclaration(): MethodDeclarationContext {
		let _localctx: MethodDeclarationContext = new MethodDeclarationContext(this._ctx, this.state);
		this.enterRule(_localctx, 4, CymbolParser.RULE_methodDeclaration);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 44;
			this.type();
			this.state = 45;
			this.match(CymbolParser.ID);
			this.state = 46;
			this.match(CymbolParser.T__2);
			this.state = 48;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << CymbolParser.T__11) | (1 << CymbolParser.T__12) | (1 << CymbolParser.T__13) | (1 << CymbolParser.ID))) !== 0)) {
				{
				this.state = 47;
				this.formalParmeters();
				}
			}

			this.state = 50;
			this.match(CymbolParser.T__3);
			this.state = 51;
			this.block();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public formalParmeters(): FormalParmetersContext {
		let _localctx: FormalParmetersContext = new FormalParmetersContext(this._ctx, this.state);
		this.enterRule(_localctx, 6, CymbolParser.RULE_formalParmeters);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 53;
			this.type();
			this.state = 54;
			this.match(CymbolParser.ID);
			this.state = 61;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === CymbolParser.T__4) {
				{
				{
				this.state = 55;
				this.match(CymbolParser.T__4);
				this.state = 56;
				this.type();
				this.state = 57;
				this.match(CymbolParser.ID);
				}
				}
				this.state = 63;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public block(): BlockContext {
		let _localctx: BlockContext = new BlockContext(this._ctx, this.state);
		this.enterRule(_localctx, 8, CymbolParser.RULE_block);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 64;
			this.match(CymbolParser.T__5);
			this.state = 68;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << CymbolParser.T__2) | (1 << CymbolParser.T__5) | (1 << CymbolParser.T__7) | (1 << CymbolParser.T__8) | (1 << CymbolParser.T__11) | (1 << CymbolParser.T__12) | (1 << CymbolParser.T__13) | (1 << CymbolParser.ID) | (1 << CymbolParser.INT))) !== 0)) {
				{
				{
				this.state = 65;
				this.statement();
				}
				}
				this.state = 70;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 71;
			this.match(CymbolParser.T__6);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public structDeclaration(): StructDeclarationContext {
		let _localctx: StructDeclarationContext = new StructDeclarationContext(this._ctx, this.state);
		this.enterRule(_localctx, 10, CymbolParser.RULE_structDeclaration);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 73;
			this.match(CymbolParser.T__7);
			this.state = 74;
			this.match(CymbolParser.ID);
			this.state = 75;
			this.match(CymbolParser.T__5);
			this.state = 77;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			do {
				{
				{
				this.state = 76;
				this.structMember();
				}
				}
				this.state = 79;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			} while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << CymbolParser.T__7) | (1 << CymbolParser.T__11) | (1 << CymbolParser.T__12) | (1 << CymbolParser.T__13) | (1 << CymbolParser.ID))) !== 0));
			this.state = 81;
			this.match(CymbolParser.T__6);
			this.state = 82;
			this.match(CymbolParser.T__1);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public structMember(): StructMemberContext {
		let _localctx: StructMemberContext = new StructMemberContext(this._ctx, this.state);
		this.enterRule(_localctx, 12, CymbolParser.RULE_structMember);
		try {
			this.state = 89;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case CymbolParser.T__11:
			case CymbolParser.T__12:
			case CymbolParser.T__13:
			case CymbolParser.ID:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 84;
				this.type();
				this.state = 85;
				this.match(CymbolParser.ID);
				this.state = 86;
				this.match(CymbolParser.T__1);
				}
				break;
			case CymbolParser.T__7:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 88;
				this.structDeclaration();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public statement(): StatementContext {
		let _localctx: StatementContext = new StatementContext(this._ctx, this.state);
		this.enterRule(_localctx, 14, CymbolParser.RULE_statement);
		let _la: number;
		try {
			this.state = 107;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 10, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 91;
				this.block();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 92;
				this.varDeclaration();
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 93;
				this.structDeclaration();
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 94;
				this.match(CymbolParser.T__8);
				this.state = 96;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << CymbolParser.T__2) | (1 << CymbolParser.ID) | (1 << CymbolParser.INT))) !== 0)) {
					{
					this.state = 95;
					this.expression();
					}
				}

				this.state = 98;
				this.match(CymbolParser.T__1);
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 99;
				this.postfixEpression();
				this.state = 103;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case CymbolParser.T__0:
					{
					this.state = 100;
					this.match(CymbolParser.T__0);
					this.state = 101;
					this.expression();
					}
					break;
				case CymbolParser.T__1:
					// tslint:disable-next-line:no-empty
					{
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 105;
				this.match(CymbolParser.T__1);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public expressionList(): ExpressionListContext {
		let _localctx: ExpressionListContext = new ExpressionListContext(this._ctx, this.state);
		this.enterRule(_localctx, 16, CymbolParser.RULE_expressionList);
		let _la: number;
		try {
			this.state = 118;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case CymbolParser.T__2:
			case CymbolParser.ID:
			case CymbolParser.INT:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 109;
				this.expression();
				this.state = 114;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === CymbolParser.T__4) {
					{
					{
					this.state = 110;
					this.match(CymbolParser.T__4);
					this.state = 111;
					this.expression();
					}
					}
					this.state = 116;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				}
				break;
			case CymbolParser.T__3:
				this.enterOuterAlt(_localctx, 2);
				// tslint:disable-next-line:no-empty
				{
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public expression(): ExpressionContext {
		let _localctx: ExpressionContext = new ExpressionContext(this._ctx, this.state);
		this.enterRule(_localctx, 18, CymbolParser.RULE_expression);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 120;
			this.addExpression();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public addExpression(): AddExpressionContext {
		let _localctx: AddExpressionContext = new AddExpressionContext(this._ctx, this.state);
		this.enterRule(_localctx, 20, CymbolParser.RULE_addExpression);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 122;
			this.postfixEpression();
			this.state = 127;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === CymbolParser.T__9) {
				{
				{
				this.state = 123;
				this.match(CymbolParser.T__9);
				this.state = 124;
				this.postfixEpression();
				}
				}
				this.state = 129;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public postfixEpression(): PostfixEpressionContext {
		let _localctx: PostfixEpressionContext = new PostfixEpressionContext(this._ctx, this.state);
		this.enterRule(_localctx, 22, CymbolParser.RULE_postfixEpression);
		let _la: number;
		try {
			this.state = 148;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 16, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 130;
				this.primary();
				this.state = 137;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === CymbolParser.T__2) {
					{
					{
					this.state = 131;
					this.match(CymbolParser.T__2);
					this.state = 132;
					this.expressionList();
					this.state = 133;
					this.match(CymbolParser.T__3);
					}
					}
					this.state = 139;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 140;
				this.primary();
				this.state = 145;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === CymbolParser.T__10) {
					{
					{
					this.state = 141;
					this.match(CymbolParser.T__10);
					this.state = 142;
					this.match(CymbolParser.ID);
					}
					}
					this.state = 147;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public primary(): PrimaryContext {
		let _localctx: PrimaryContext = new PrimaryContext(this._ctx, this.state);
		this.enterRule(_localctx, 24, CymbolParser.RULE_primary);
		try {
			this.state = 156;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case CymbolParser.INT:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 150;
				this.match(CymbolParser.INT);
				}
				break;
			case CymbolParser.ID:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 151;
				this.match(CymbolParser.ID);
				}
				break;
			case CymbolParser.T__2:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 152;
				this.match(CymbolParser.T__2);
				this.state = 153;
				this.expression();
				this.state = 154;
				this.match(CymbolParser.T__3);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public type(): TypeContext {
		let _localctx: TypeContext = new TypeContext(this._ctx, this.state);
		this.enterRule(_localctx, 26, CymbolParser.RULE_type);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 158;
			_la = this._input.LA(1);
			if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << CymbolParser.T__11) | (1 << CymbolParser.T__12) | (1 << CymbolParser.T__13) | (1 << CymbolParser.ID))) !== 0))) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}

	public static readonly _serializedATN: string =
		"\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\x14\xA3\x04\x02" +
		"\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07" +
		"\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r\t\r\x04" +
		"\x0E\t\x0E\x04\x0F\t\x0F\x03\x02\x03\x02\x03\x02\x07\x02\"\n\x02\f\x02" +
		"\x0E\x02%\v\x02\x03\x03\x03\x03\x03\x03\x03\x03\x05\x03+\n\x03\x03\x03" +
		"\x03\x03\x03\x04\x03\x04\x03\x04\x03\x04\x05\x043\n\x04\x03\x04\x03\x04" +
		"\x03\x04\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x07\x05>\n\x05" +
		"\f\x05\x0E\x05A\v\x05\x03\x06\x03\x06\x07\x06E\n\x06\f\x06\x0E\x06H\v" +
		"\x06\x03\x06\x03\x06\x03\x07\x03\x07\x03\x07\x03\x07\x06\x07P\n\x07\r" +
		"\x07\x0E\x07Q\x03\x07\x03\x07\x03\x07\x03\b\x03\b\x03\b\x03\b\x03\b\x05" +
		"\b\\\n\b\x03\t\x03\t\x03\t\x03\t\x03\t\x05\tc\n\t\x03\t\x03\t\x03\t\x03" +
		"\t\x03\t\x05\tj\n\t\x03\t\x03\t\x05\tn\n\t\x03\n\x03\n\x03\n\x07\ns\n" +
		"\n\f\n\x0E\nv\v\n\x03\n\x05\ny\n\n\x03\v\x03\v\x03\f\x03\f\x03\f\x07\f" +
		"\x80\n\f\f\f\x0E\f\x83\v\f\x03\r\x03\r\x03\r\x03\r\x03\r\x07\r\x8A\n\r" +
		"\f\r\x0E\r\x8D\v\r\x03\r\x03\r\x03\r\x07\r\x92\n\r\f\r\x0E\r\x95\v\r\x05" +
		"\r\x97\n\r\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x05\x0E\x9F" +
		"\n\x0E\x03\x0F\x03\x0F\x03\x0F\x02\x02\x02\x10\x02\x02\x04\x02\x06\x02" +
		"\b\x02\n\x02\f\x02\x0E\x02\x10\x02\x12\x02\x14\x02\x16\x02\x18\x02\x1A" +
		"\x02\x1C\x02\x02\x03\x03\x02\x0E\x11\x02\xAB\x02#\x03\x02\x02\x02\x04" +
		"&\x03\x02\x02\x02\x06.\x03\x02\x02\x02\b7\x03\x02\x02\x02\nB\x03\x02\x02" +
		"\x02\fK\x03\x02\x02\x02\x0E[\x03\x02\x02\x02\x10m\x03\x02\x02\x02\x12" +
		"x\x03\x02\x02\x02\x14z\x03\x02\x02\x02\x16|\x03\x02\x02\x02\x18\x96\x03" +
		"\x02\x02\x02\x1A\x9E\x03\x02\x02\x02\x1C\xA0\x03\x02\x02\x02\x1E\"\x05" +
		"\x04\x03\x02\x1F\"\x05\x06\x04\x02 \"\x05\f\x07\x02!\x1E\x03\x02\x02\x02" +
		"!\x1F\x03\x02\x02\x02! \x03\x02\x02\x02\"%\x03\x02\x02\x02#!\x03\x02\x02" +
		"\x02#$\x03\x02\x02\x02$\x03\x03\x02\x02\x02%#\x03\x02\x02\x02&\'\x05\x1C" +
		"\x0F\x02\'*\x07\x11\x02\x02()\x07\x03\x02\x02)+\x05\x14\v\x02*(\x03\x02" +
		"\x02\x02*+\x03\x02\x02\x02+,\x03\x02\x02\x02,-\x07\x04\x02\x02-\x05\x03" +
		"\x02\x02\x02./\x05\x1C\x0F\x02/0\x07\x11\x02\x0202\x07\x05\x02\x0213\x05" +
		"\b\x05\x0221\x03\x02\x02\x0223\x03\x02\x02\x0234\x03\x02\x02\x0245\x07" +
		"\x06\x02\x0256\x05\n\x06\x026\x07\x03\x02\x02\x0278\x05\x1C\x0F\x028?" +
		"\x07\x11\x02\x029:\x07\x07\x02\x02:;\x05\x1C\x0F\x02;<\x07\x11\x02\x02" +
		"<>\x03\x02\x02\x02=9\x03\x02\x02\x02>A\x03\x02\x02\x02?=\x03\x02\x02\x02" +
		"?@\x03\x02\x02\x02@\t\x03\x02\x02\x02A?\x03\x02\x02\x02BF\x07\b\x02\x02" +
		"CE\x05\x10\t\x02DC\x03\x02\x02\x02EH\x03\x02\x02\x02FD\x03\x02\x02\x02" +
		"FG\x03\x02\x02\x02GI\x03\x02\x02\x02HF\x03\x02\x02\x02IJ\x07\t\x02\x02" +
		"J\v\x03\x02\x02\x02KL\x07\n\x02\x02LM\x07\x11\x02\x02MO\x07\b\x02\x02" +
		"NP\x05\x0E\b\x02ON\x03\x02\x02\x02PQ\x03\x02\x02\x02QO\x03\x02\x02\x02" +
		"QR\x03\x02\x02\x02RS\x03\x02\x02\x02ST\x07\t\x02\x02TU\x07\x04\x02\x02" +
		"U\r\x03\x02\x02\x02VW\x05\x1C\x0F\x02WX\x07\x11\x02\x02XY\x07\x04\x02" +
		"\x02Y\\\x03\x02\x02\x02Z\\\x05\f\x07\x02[V\x03\x02\x02\x02[Z\x03\x02\x02" +
		"\x02\\\x0F\x03\x02\x02\x02]n\x05\n\x06\x02^n\x05\x04\x03\x02_n\x05\f\x07" +
		"\x02`b\x07\v\x02\x02ac\x05\x14\v\x02ba\x03\x02\x02\x02bc\x03\x02\x02\x02" +
		"cd\x03\x02\x02\x02dn\x07\x04\x02\x02ei\x05\x18\r\x02fg\x07\x03\x02\x02" +
		"gj\x05\x14\v\x02hj\x03\x02\x02\x02if\x03\x02\x02\x02ih\x03\x02\x02\x02" +
		"jk\x03\x02\x02\x02kl\x07\x04\x02\x02ln\x03\x02\x02\x02m]\x03\x02\x02\x02" +
		"m^\x03\x02\x02\x02m_\x03\x02\x02\x02m`\x03\x02\x02\x02me\x03\x02\x02\x02" +
		"n\x11\x03\x02\x02\x02ot\x05\x14\v\x02pq\x07\x07\x02\x02qs\x05\x14\v\x02" +
		"rp\x03\x02\x02\x02sv\x03\x02\x02\x02tr\x03\x02\x02\x02tu\x03\x02\x02\x02" +
		"uy\x03\x02\x02\x02vt\x03\x02\x02\x02wy\x03\x02\x02\x02xo\x03\x02\x02\x02" +
		"xw\x03\x02\x02\x02y\x13\x03\x02\x02\x02z{\x05\x16\f\x02{\x15\x03\x02\x02" +
		"\x02|\x81\x05\x18\r\x02}~\x07\f\x02\x02~\x80\x05\x18\r\x02\x7F}\x03\x02" +
		"\x02\x02\x80\x83\x03\x02\x02\x02\x81\x7F\x03\x02\x02\x02\x81\x82\x03\x02" +
		"\x02\x02\x82\x17\x03\x02\x02\x02\x83\x81\x03\x02\x02\x02\x84\x8B\x05\x1A" +
		"\x0E\x02\x85\x86\x07\x05\x02\x02\x86\x87\x05\x12\n\x02\x87\x88\x07\x06" +
		"\x02\x02\x88\x8A\x03\x02\x02\x02\x89\x85\x03\x02\x02\x02\x8A\x8D\x03\x02" +
		"\x02\x02\x8B\x89\x03\x02\x02\x02\x8B\x8C\x03\x02\x02\x02\x8C\x97\x03\x02" +
		"\x02\x02\x8D\x8B\x03\x02\x02\x02\x8E\x93\x05\x1A\x0E\x02\x8F\x90\x07\r" +
		"\x02\x02\x90\x92\x07\x11\x02\x02\x91\x8F\x03\x02\x02\x02\x92\x95\x03\x02" +
		"\x02\x02\x93\x91\x03\x02\x02\x02\x93\x94\x03\x02\x02\x02\x94\x97\x03\x02" +
		"\x02\x02\x95\x93\x03\x02\x02\x02\x96\x84\x03\x02\x02\x02\x96\x8E\x03\x02" +
		"\x02\x02\x97\x19\x03\x02\x02\x02\x98\x9F\x07\x12\x02\x02\x99\x9F\x07\x11" +
		"\x02\x02\x9A\x9B\x07\x05\x02\x02\x9B\x9C\x05\x14\v\x02\x9C\x9D\x07\x06" +
		"\x02\x02\x9D\x9F\x03\x02\x02\x02\x9E\x98\x03\x02\x02\x02\x9E\x99\x03\x02" +
		"\x02\x02\x9E\x9A\x03\x02\x02\x02\x9F\x1B\x03\x02\x02\x02\xA0\xA1\t\x02" +
		"\x02\x02\xA1\x1D\x03\x02\x02\x02\x14!#*2?FQ[bimtx\x81\x8B\x93\x96\x9E";
	public static __ATN: ATN;
	public static get _ATN(): ATN {
		if (!CymbolParser.__ATN) {
			CymbolParser.__ATN = new ATNDeserializer().deserialize(Utils.toCharArray(CymbolParser._serializedATN));
		}

		return CymbolParser.__ATN;
	}

}

export class CompilationUnitContext extends ParserRuleContext {
	public varDeclaration(): VarDeclarationContext[];
	public varDeclaration(i: number): VarDeclarationContext;
	public varDeclaration(i?: number): VarDeclarationContext | VarDeclarationContext[] {
		if (i === undefined) {
			return this.getRuleContexts(VarDeclarationContext);
		} else {
			return this.getRuleContext(i, VarDeclarationContext);
		}
	}
	public methodDeclaration(): MethodDeclarationContext[];
	public methodDeclaration(i: number): MethodDeclarationContext;
	public methodDeclaration(i?: number): MethodDeclarationContext | MethodDeclarationContext[] {
		if (i === undefined) {
			return this.getRuleContexts(MethodDeclarationContext);
		} else {
			return this.getRuleContext(i, MethodDeclarationContext);
		}
	}
	public structDeclaration(): StructDeclarationContext[];
	public structDeclaration(i: number): StructDeclarationContext;
	public structDeclaration(i?: number): StructDeclarationContext | StructDeclarationContext[] {
		if (i === undefined) {
			return this.getRuleContexts(StructDeclarationContext);
		} else {
			return this.getRuleContext(i, StructDeclarationContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CymbolParser.RULE_compilationUnit; }
	// @Override
	public enterRule(listener: CymbolListener): void {
		if (listener.enterCompilationUnit) {
			listener.enterCompilationUnit(this);
		}
	}
	// @Override
	public exitRule(listener: CymbolListener): void {
		if (listener.exitCompilationUnit) {
			listener.exitCompilationUnit(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CymbolVisitor<Result>): Result {
		if (visitor.visitCompilationUnit) {
			return visitor.visitCompilationUnit(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class VarDeclarationContext extends ParserRuleContext {
	public type(): TypeContext {
		return this.getRuleContext(0, TypeContext);
	}
	public ID(): TerminalNode { return this.getToken(CymbolParser.ID, 0); }
	public expression(): ExpressionContext | undefined {
		return this.tryGetRuleContext(0, ExpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CymbolParser.RULE_varDeclaration; }
	// @Override
	public enterRule(listener: CymbolListener): void {
		if (listener.enterVarDeclaration) {
			listener.enterVarDeclaration(this);
		}
	}
	// @Override
	public exitRule(listener: CymbolListener): void {
		if (listener.exitVarDeclaration) {
			listener.exitVarDeclaration(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CymbolVisitor<Result>): Result {
		if (visitor.visitVarDeclaration) {
			return visitor.visitVarDeclaration(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class MethodDeclarationContext extends ParserRuleContext {
	public type(): TypeContext {
		return this.getRuleContext(0, TypeContext);
	}
	public ID(): TerminalNode { return this.getToken(CymbolParser.ID, 0); }
	public block(): BlockContext {
		return this.getRuleContext(0, BlockContext);
	}
	public formalParmeters(): FormalParmetersContext | undefined {
		return this.tryGetRuleContext(0, FormalParmetersContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CymbolParser.RULE_methodDeclaration; }
	// @Override
	public enterRule(listener: CymbolListener): void {
		if (listener.enterMethodDeclaration) {
			listener.enterMethodDeclaration(this);
		}
	}
	// @Override
	public exitRule(listener: CymbolListener): void {
		if (listener.exitMethodDeclaration) {
			listener.exitMethodDeclaration(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CymbolVisitor<Result>): Result {
		if (visitor.visitMethodDeclaration) {
			return visitor.visitMethodDeclaration(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FormalParmetersContext extends ParserRuleContext {
	public type(): TypeContext[];
	public type(i: number): TypeContext;
	public type(i?: number): TypeContext | TypeContext[] {
		if (i === undefined) {
			return this.getRuleContexts(TypeContext);
		} else {
			return this.getRuleContext(i, TypeContext);
		}
	}
	public ID(): TerminalNode[];
	public ID(i: number): TerminalNode;
	public ID(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CymbolParser.ID);
		} else {
			return this.getToken(CymbolParser.ID, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CymbolParser.RULE_formalParmeters; }
	// @Override
	public enterRule(listener: CymbolListener): void {
		if (listener.enterFormalParmeters) {
			listener.enterFormalParmeters(this);
		}
	}
	// @Override
	public exitRule(listener: CymbolListener): void {
		if (listener.exitFormalParmeters) {
			listener.exitFormalParmeters(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CymbolVisitor<Result>): Result {
		if (visitor.visitFormalParmeters) {
			return visitor.visitFormalParmeters(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class BlockContext extends ParserRuleContext {
	public statement(): StatementContext[];
	public statement(i: number): StatementContext;
	public statement(i?: number): StatementContext | StatementContext[] {
		if (i === undefined) {
			return this.getRuleContexts(StatementContext);
		} else {
			return this.getRuleContext(i, StatementContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CymbolParser.RULE_block; }
	// @Override
	public enterRule(listener: CymbolListener): void {
		if (listener.enterBlock) {
			listener.enterBlock(this);
		}
	}
	// @Override
	public exitRule(listener: CymbolListener): void {
		if (listener.exitBlock) {
			listener.exitBlock(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CymbolVisitor<Result>): Result {
		if (visitor.visitBlock) {
			return visitor.visitBlock(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class StructDeclarationContext extends ParserRuleContext {
	public ID(): TerminalNode { return this.getToken(CymbolParser.ID, 0); }
	public structMember(): StructMemberContext[];
	public structMember(i: number): StructMemberContext;
	public structMember(i?: number): StructMemberContext | StructMemberContext[] {
		if (i === undefined) {
			return this.getRuleContexts(StructMemberContext);
		} else {
			return this.getRuleContext(i, StructMemberContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CymbolParser.RULE_structDeclaration; }
	// @Override
	public enterRule(listener: CymbolListener): void {
		if (listener.enterStructDeclaration) {
			listener.enterStructDeclaration(this);
		}
	}
	// @Override
	public exitRule(listener: CymbolListener): void {
		if (listener.exitStructDeclaration) {
			listener.exitStructDeclaration(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CymbolVisitor<Result>): Result {
		if (visitor.visitStructDeclaration) {
			return visitor.visitStructDeclaration(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class StructMemberContext extends ParserRuleContext {
	public type(): TypeContext | undefined {
		return this.tryGetRuleContext(0, TypeContext);
	}
	public ID(): TerminalNode | undefined { return this.tryGetToken(CymbolParser.ID, 0); }
	public structDeclaration(): StructDeclarationContext | undefined {
		return this.tryGetRuleContext(0, StructDeclarationContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CymbolParser.RULE_structMember; }
	// @Override
	public enterRule(listener: CymbolListener): void {
		if (listener.enterStructMember) {
			listener.enterStructMember(this);
		}
	}
	// @Override
	public exitRule(listener: CymbolListener): void {
		if (listener.exitStructMember) {
			listener.exitStructMember(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CymbolVisitor<Result>): Result {
		if (visitor.visitStructMember) {
			return visitor.visitStructMember(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class StatementContext extends ParserRuleContext {
	public block(): BlockContext | undefined {
		return this.tryGetRuleContext(0, BlockContext);
	}
	public varDeclaration(): VarDeclarationContext | undefined {
		return this.tryGetRuleContext(0, VarDeclarationContext);
	}
	public structDeclaration(): StructDeclarationContext | undefined {
		return this.tryGetRuleContext(0, StructDeclarationContext);
	}
	public expression(): ExpressionContext | undefined {
		return this.tryGetRuleContext(0, ExpressionContext);
	}
	public postfixEpression(): PostfixEpressionContext | undefined {
		return this.tryGetRuleContext(0, PostfixEpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CymbolParser.RULE_statement; }
	// @Override
	public enterRule(listener: CymbolListener): void {
		if (listener.enterStatement) {
			listener.enterStatement(this);
		}
	}
	// @Override
	public exitRule(listener: CymbolListener): void {
		if (listener.exitStatement) {
			listener.exitStatement(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CymbolVisitor<Result>): Result {
		if (visitor.visitStatement) {
			return visitor.visitStatement(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ExpressionListContext extends ParserRuleContext {
	public expression(): ExpressionContext[];
	public expression(i: number): ExpressionContext;
	public expression(i?: number): ExpressionContext | ExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExpressionContext);
		} else {
			return this.getRuleContext(i, ExpressionContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CymbolParser.RULE_expressionList; }
	// @Override
	public enterRule(listener: CymbolListener): void {
		if (listener.enterExpressionList) {
			listener.enterExpressionList(this);
		}
	}
	// @Override
	public exitRule(listener: CymbolListener): void {
		if (listener.exitExpressionList) {
			listener.exitExpressionList(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CymbolVisitor<Result>): Result {
		if (visitor.visitExpressionList) {
			return visitor.visitExpressionList(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ExpressionContext extends ParserRuleContext {
	public addExpression(): AddExpressionContext {
		return this.getRuleContext(0, AddExpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CymbolParser.RULE_expression; }
	// @Override
	public enterRule(listener: CymbolListener): void {
		if (listener.enterExpression) {
			listener.enterExpression(this);
		}
	}
	// @Override
	public exitRule(listener: CymbolListener): void {
		if (listener.exitExpression) {
			listener.exitExpression(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CymbolVisitor<Result>): Result {
		if (visitor.visitExpression) {
			return visitor.visitExpression(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class AddExpressionContext extends ParserRuleContext {
	public postfixEpression(): PostfixEpressionContext[];
	public postfixEpression(i: number): PostfixEpressionContext;
	public postfixEpression(i?: number): PostfixEpressionContext | PostfixEpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(PostfixEpressionContext);
		} else {
			return this.getRuleContext(i, PostfixEpressionContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CymbolParser.RULE_addExpression; }
	// @Override
	public enterRule(listener: CymbolListener): void {
		if (listener.enterAddExpression) {
			listener.enterAddExpression(this);
		}
	}
	// @Override
	public exitRule(listener: CymbolListener): void {
		if (listener.exitAddExpression) {
			listener.exitAddExpression(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CymbolVisitor<Result>): Result {
		if (visitor.visitAddExpression) {
			return visitor.visitAddExpression(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PostfixEpressionContext extends ParserRuleContext {
	public primary(): PrimaryContext {
		return this.getRuleContext(0, PrimaryContext);
	}
	public expressionList(): ExpressionListContext[];
	public expressionList(i: number): ExpressionListContext;
	public expressionList(i?: number): ExpressionListContext | ExpressionListContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExpressionListContext);
		} else {
			return this.getRuleContext(i, ExpressionListContext);
		}
	}
	public ID(): TerminalNode[];
	public ID(i: number): TerminalNode;
	public ID(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(CymbolParser.ID);
		} else {
			return this.getToken(CymbolParser.ID, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CymbolParser.RULE_postfixEpression; }
	// @Override
	public enterRule(listener: CymbolListener): void {
		if (listener.enterPostfixEpression) {
			listener.enterPostfixEpression(this);
		}
	}
	// @Override
	public exitRule(listener: CymbolListener): void {
		if (listener.exitPostfixEpression) {
			listener.exitPostfixEpression(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CymbolVisitor<Result>): Result {
		if (visitor.visitPostfixEpression) {
			return visitor.visitPostfixEpression(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PrimaryContext extends ParserRuleContext {
	public INT(): TerminalNode | undefined { return this.tryGetToken(CymbolParser.INT, 0); }
	public ID(): TerminalNode | undefined { return this.tryGetToken(CymbolParser.ID, 0); }
	public expression(): ExpressionContext | undefined {
		return this.tryGetRuleContext(0, ExpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CymbolParser.RULE_primary; }
	// @Override
	public enterRule(listener: CymbolListener): void {
		if (listener.enterPrimary) {
			listener.enterPrimary(this);
		}
	}
	// @Override
	public exitRule(listener: CymbolListener): void {
		if (listener.exitPrimary) {
			listener.exitPrimary(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CymbolVisitor<Result>): Result {
		if (visitor.visitPrimary) {
			return visitor.visitPrimary(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class TypeContext extends ParserRuleContext {
	public ID(): TerminalNode { return this.getToken(CymbolParser.ID, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return CymbolParser.RULE_type; }
	// @Override
	public enterRule(listener: CymbolListener): void {
		if (listener.enterType) {
			listener.enterType(this);
		}
	}
	// @Override
	public exitRule(listener: CymbolListener): void {
		if (listener.exitType) {
			listener.exitType(this);
		}
	}
	// @Override
	public accept<Result>(visitor: CymbolVisitor<Result>): Result {
		if (visitor.visitType) {
			return visitor.visitType(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


